package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade HIDROMETRO_ENSAIO
 * @author Gerado pelo Telescope
 */
public class EntHidrometroEnsaio extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.HIDROMETRO_ENSAIO";
    public final static String TABLE_NAME = "HIDROMETRO_ENSAIO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntHidrometroEnsaio() {
        super();
        initialize();
    }
    
    public EntHidrometroEnsaio(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aEnsaioBancadaId = new DomId(this,"ENSAIO_BANCADA_ID", "Ensaio da bancada"); 
        aEnsaioBancadaId.setRequired(true);
        oEnsaioBancadaId = new DomId();
        aPosicaoModelo = new DomInteger(this,"POSICAO_MODELO", "Posição do modelo"); 
        aPosicaoModelo.setRequired(true);
        oPosicaoModelo = new DomInteger();
        aDestino = new DomOption(this,"DESTINO", "Destino (após ensaio)"); 
        aDestino.setRequired(true);
        aDestino.setSize(1);
        aDestino.clearOptions();
        aDestino.addOption("A", "Aguardando inicio do ensaio");
        aDestino.addOption("C", "Liberado para o Cliente");
        aDestino.addOption("E", "Liberado para o Estoque");
        aDestino.addOption("M", "Retornou para montagem");
        aDestino.setDefaultValue("A");
        oDestino = new DomOption();
        aSituacao = new DomOpcao(this,"SITUACAO", "Situação"); 
        aSituacao.setRequired(true);
        aSituacao.setSize(1);
        aSituacao.clearOptions();
        aSituacao.addOption("A", "Aprovado");
        aSituacao.addOption("E", "Em ensaio");
        aSituacao.addOption("R", "Reprovado");
        aSituacao.setDefaultValue("E");
        oSituacao = new DomOpcao();
        aSituacaoInformada = new DomOpcao(this,"SITUACAO_INFORMADA", "Situação informada"); 
        aSituacaoInformada.setSize(1);
        aSituacaoInformada.clearOptions();
        aSituacaoInformada.addOption("A", "Aprovado");
        aSituacaoInformada.addOption("R", "Reprovado");
        oSituacaoInformada = new DomOpcao();
        aMotivoAprovaoReprovaId = new DomId(this,"MOTIVO_APROVAO_REPROVA_ID", "Motivo de aprovação e reprovação"); 
        oMotivoAprovaoReprovaId = new DomId();
        aParecer = new DomTextLong(this,"PARECER", "Parecer sobre o motivo"); 
        aParecer.setSize(256);
        oParecer = new DomTextLong();
        aNumeroSerie = new DomText(this,"NUMERO_SERIE", "Número de série do hidrômetro"); 
        aNumeroSerie.setSize(32);
        oNumeroSerie = new DomText();
        aHidrometroId = new DomId(this,"HIDROMETRO_ID", "Hidrômetro aprovado"); 
        oHidrometroId = new DomId();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Ensaio da bancada
    private DomId aEnsaioBancadaId;
    private DomId oEnsaioBancadaId;
    
    // Posição do modelo
    private DomInteger aPosicaoModelo;
    private DomInteger oPosicaoModelo;
    
    // Destino (após ensaio)
    private DomOption aDestino;
    private DomOption oDestino;
    
    // Situação
    private DomOpcao aSituacao;
    private DomOpcao oSituacao;
    
    // Situação informada
    private DomOpcao aSituacaoInformada;
    private DomOpcao oSituacaoInformada;
    
    // Motivo de aprovação e reprovação
    private DomId aMotivoAprovaoReprovaId;
    private DomId oMotivoAprovaoReprovaId;
    
    // Parecer sobre o motivo
    private DomTextLong aParecer;
    private DomTextLong oParecer;
    
    // Número de série do hidrômetro
    private DomText aNumeroSerie;
    private DomText oNumeroSerie;
    
    // Hidrômetro aprovado
    private DomId aHidrometroId;
    private DomId oHidrometroId;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntHidrometroEnsaio id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ENSAIO_BANCADA_ID">
    
    public EntHidrometroEnsaio ensaioBancadaId(Long value) {
        setEnsaioBancadaId(value);
        return this;
    }
    
    public void setEnsaioBancadaId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyEnsaioBancadaId();
        } else {
            aEnsaioBancadaId.setValue(value.getValue());
            if (aEnsaioBancadaId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setEnsaioBancadaId(String value) {
        if (value == null) {
            nullifyEnsaioBancadaId();
        } else {
            aEnsaioBancadaId.setValue(value);
            if (aEnsaioBancadaId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setEnsaioBancadaId(Long value) {
        aEnsaioBancadaId.setValue(value);
        if (aEnsaioBancadaId.isModified()) {
            setModified(true);
        }
    }
    
    public void setEnsaioBancadaId(Object value) {
        aEnsaioBancadaId.setValue(value);
        if (aEnsaioBancadaId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyEnsaioBancadaId() {
        if (!aEnsaioBancadaId.isNull()) {
            aEnsaioBancadaId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getEnsaioBancadaId() {
        return aEnsaioBancadaId;
    }
    
    public DomId oldEnsaioBancadaId() {
        return oEnsaioBancadaId;
    }
    
    public Long valueOfEnsaioBancadaId() {
        return aEnsaioBancadaId.getValue();
    }
    
    public boolean isEnsaioBancadaIdModified() {
        return aEnsaioBancadaId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo POSICAO_MODELO">
    
    public EntHidrometroEnsaio posicaoModelo(Integer value) {
        setPosicaoModelo(value);
        return this;
    }
    
    public void setPosicaoModelo(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyPosicaoModelo();
        } else {
            aPosicaoModelo.setValue(value.getValue());
            if (aPosicaoModelo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPosicaoModelo(String value) {
        if (value == null) {
            nullifyPosicaoModelo();
        } else {
            aPosicaoModelo.setValue(value);
            if (aPosicaoModelo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPosicaoModelo(Integer value) {
        aPosicaoModelo.setValue(value);
        if (aPosicaoModelo.isModified()) {
            setModified(true);
        }
    }
    
    public void setPosicaoModelo(Object value) {
        aPosicaoModelo.setValue(value);
        if (aPosicaoModelo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPosicaoModelo() {
        if (!aPosicaoModelo.isNull()) {
            aPosicaoModelo.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getPosicaoModelo() {
        return aPosicaoModelo;
    }
    
    public DomInteger oldPosicaoModelo() {
        return oPosicaoModelo;
    }
    
    public Integer valueOfPosicaoModelo() {
        return aPosicaoModelo.getValue();
    }
    
    public boolean isPosicaoModeloModified() {
        return aPosicaoModelo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DESTINO">
    
    public EntHidrometroEnsaio destino(String value) {
        setDestino(value);
        return this;
    }
    
    public void setDestino(DomOption value) {
        if (value == null || value.isNull()) {
            nullifyDestino();
        } else {
            aDestino.setValue(value.getValue());
            if (aDestino.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDestino(String value) {
        if (value == null) {
            nullifyDestino();
        } else {
            aDestino.setValue(value);
            if (aDestino.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDestino(Object value) {
        aDestino.setValue(value);
        if (aDestino.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDestino() {
        if (!aDestino.isNull()) {
            aDestino.setNull(true);
            setModified(true);
        }
    }
    
    public DomOption getDestino() {
        return aDestino;
    }
    
    public DomOption oldDestino() {
        return oDestino;
    }
    
    public String valueOfDestino() {
        return aDestino.getValue();
    }
    
    public boolean isDestinoModified() {
        return aDestino.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SITUACAO">
    
    public EntHidrometroEnsaio situacao(String value) {
        setSituacao(value);
        return this;
    }
    
    public void setSituacao(DomOpcao value) {
        if (value == null || value.isNull()) {
            nullifySituacao();
        } else {
            aSituacao.setValue(value.getValue());
            if (aSituacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSituacao(String value) {
        if (value == null) {
            nullifySituacao();
        } else {
            aSituacao.setValue(value);
            if (aSituacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSituacao(Object value) {
        aSituacao.setValue(value);
        if (aSituacao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySituacao() {
        if (!aSituacao.isNull()) {
            aSituacao.setNull(true);
            setModified(true);
        }
    }
    
    public DomOpcao getSituacao() {
        return aSituacao;
    }
    
    public DomOpcao oldSituacao() {
        return oSituacao;
    }
    
    public String valueOfSituacao() {
        return aSituacao.getValue();
    }
    
    public boolean isSituacaoModified() {
        return aSituacao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SITUACAO_INFORMADA">
    
    public EntHidrometroEnsaio situacaoInformada(String value) {
        setSituacaoInformada(value);
        return this;
    }
    
    public void setSituacaoInformada(DomOpcao value) {
        if (value == null || value.isNull()) {
            nullifySituacaoInformada();
        } else {
            aSituacaoInformada.setValue(value.getValue());
            if (aSituacaoInformada.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSituacaoInformada(String value) {
        if (value == null) {
            nullifySituacaoInformada();
        } else {
            aSituacaoInformada.setValue(value);
            if (aSituacaoInformada.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSituacaoInformada(Object value) {
        aSituacaoInformada.setValue(value);
        if (aSituacaoInformada.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySituacaoInformada() {
        if (!aSituacaoInformada.isNull()) {
            aSituacaoInformada.setNull(true);
            setModified(true);
        }
    }
    
    public DomOpcao getSituacaoInformada() {
        return aSituacaoInformada;
    }
    
    public DomOpcao oldSituacaoInformada() {
        return oSituacaoInformada;
    }
    
    public String valueOfSituacaoInformada() {
        return aSituacaoInformada.getValue();
    }
    
    public boolean isSituacaoInformadaModified() {
        return aSituacaoInformada.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo MOTIVO_APROVAO_REPROVA_ID">
    
    public EntHidrometroEnsaio motivoAprovaoReprovaId(Long value) {
        setMotivoAprovaoReprovaId(value);
        return this;
    }
    
    public void setMotivoAprovaoReprovaId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyMotivoAprovaoReprovaId();
        } else {
            aMotivoAprovaoReprovaId.setValue(value.getValue());
            if (aMotivoAprovaoReprovaId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMotivoAprovaoReprovaId(String value) {
        if (value == null) {
            nullifyMotivoAprovaoReprovaId();
        } else {
            aMotivoAprovaoReprovaId.setValue(value);
            if (aMotivoAprovaoReprovaId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMotivoAprovaoReprovaId(Long value) {
        aMotivoAprovaoReprovaId.setValue(value);
        if (aMotivoAprovaoReprovaId.isModified()) {
            setModified(true);
        }
    }
    
    public void setMotivoAprovaoReprovaId(Object value) {
        aMotivoAprovaoReprovaId.setValue(value);
        if (aMotivoAprovaoReprovaId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyMotivoAprovaoReprovaId() {
        if (!aMotivoAprovaoReprovaId.isNull()) {
            aMotivoAprovaoReprovaId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getMotivoAprovaoReprovaId() {
        return aMotivoAprovaoReprovaId;
    }
    
    public DomId oldMotivoAprovaoReprovaId() {
        return oMotivoAprovaoReprovaId;
    }
    
    public Long valueOfMotivoAprovaoReprovaId() {
        return aMotivoAprovaoReprovaId.getValue();
    }
    
    public boolean isMotivoAprovaoReprovaIdModified() {
        return aMotivoAprovaoReprovaId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PARECER">
    
    public EntHidrometroEnsaio parecer(String value) {
        setParecer(value);
        return this;
    }
    
    public void setParecer(DomTextLong value) {
        if (value == null || value.isNull()) {
            nullifyParecer();
        } else {
            aParecer.setValue(value.getValue());
            if (aParecer.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setParecer(String value) {
        if (value == null) {
            nullifyParecer();
        } else {
            aParecer.setValue(value);
            if (aParecer.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setParecer(Object value) {
        aParecer.setValue(value);
        if (aParecer.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyParecer() {
        if (!aParecer.isNull()) {
            aParecer.setNull(true);
            setModified(true);
        }
    }
    
    public DomTextLong getParecer() {
        return aParecer;
    }
    
    public DomTextLong oldParecer() {
        return oParecer;
    }
    
    public String valueOfParecer() {
        return aParecer.getValue();
    }
    
    public boolean isParecerModified() {
        return aParecer.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NUMERO_SERIE">
    
    public EntHidrometroEnsaio numeroSerie(String value) {
        setNumeroSerie(value);
        return this;
    }
    
    public void setNumeroSerie(DomText value) {
        if (value == null || value.isNull()) {
            nullifyNumeroSerie();
        } else {
            aNumeroSerie.setValue(value.getValue());
            if (aNumeroSerie.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNumeroSerie(String value) {
        if (value == null) {
            nullifyNumeroSerie();
        } else {
            aNumeroSerie.setValue(value);
            if (aNumeroSerie.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNumeroSerie(Object value) {
        aNumeroSerie.setValue(value);
        if (aNumeroSerie.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNumeroSerie() {
        if (!aNumeroSerie.isNull()) {
            aNumeroSerie.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getNumeroSerie() {
        return aNumeroSerie;
    }
    
    public DomText oldNumeroSerie() {
        return oNumeroSerie;
    }
    
    public String valueOfNumeroSerie() {
        return aNumeroSerie.getValue();
    }
    
    public boolean isNumeroSerieModified() {
        return aNumeroSerie.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo HIDROMETRO_ID">
    
    public EntHidrometroEnsaio hidrometroId(Long value) {
        setHidrometroId(value);
        return this;
    }
    
    public void setHidrometroId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyHidrometroId();
        } else {
            aHidrometroId.setValue(value.getValue());
            if (aHidrometroId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setHidrometroId(String value) {
        if (value == null) {
            nullifyHidrometroId();
        } else {
            aHidrometroId.setValue(value);
            if (aHidrometroId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setHidrometroId(Long value) {
        aHidrometroId.setValue(value);
        if (aHidrometroId.isModified()) {
            setModified(true);
        }
    }
    
    public void setHidrometroId(Object value) {
        aHidrometroId.setValue(value);
        if (aHidrometroId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyHidrometroId() {
        if (!aHidrometroId.isNull()) {
            aHidrometroId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getHidrometroId() {
        return aHidrometroId;
    }
    
    public DomId oldHidrometroId() {
        return oHidrometroId;
    }
    
    public Long valueOfHidrometroId() {
        return aHidrometroId.getValue();
    }
    
    public boolean isHidrometroIdModified() {
        return aHidrometroId.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteRestrict() throws AdsException {
        // Nullify cascade ZTEST.VALOR_VARIAVEL_ENSAIO.FK_VAVAEN_HIDROMETRO_ENSAIO
        {
            EntValorVariavelEnsaio external = new EntValorVariavelEnsaio(ctx);
            external.findByHidrometroEnsaio(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.VALOR_VARIAVEL_ENSAIO.FK_VAVAEN_HIDROMETRO_ENSAIO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Valores das variávéis nos ensaios fazendo referencia para este registro");
            }
            external.close();
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_VAVAEN_HIDROMETRO_ENSAIO") >= 0) {
                e = new AdsException("ZTEST.VALOR_VARIAVEL_ENSAIO.FK_VAVAEN_HIDROMETRO_ENSAIO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Valores das variávéis nos ensaios fazendo referencia para este registro! (FK_VAVAEN_HIDROMETRO_ENSAIO)");
                return e;
            } else {
                e = new AdsException("ZTEST.HIDROMETRO_ENSAIO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("PARECER_DEVE_SER_PREENCHIDO") >= 0) {
                e = new AdsException("ZTEST.HIDROMETRO_ENSAIO.PARECER_DEVE_SER_PREENCHIDO", 
                        Severity.ERROR,
                        "Regra inválida! Texto do motivo (parecer descritivo) deve ser preenchido para o motivo informado!  (PARECER_DEVE_SER_PREENCHIDO)");
                return e;
            } else if (msg.indexOf("FK_HROEN_HIDROMETRO") >= 0) {
                e = new AdsException("ZTEST.HIDROMETRO_ENSAIO.FK_HROEN_HIDROMETRO", 
                        Severity.ERROR,
                        "Registro não cadastrado para HIDROMETRO! (FK_HROEN_HIDROMETRO)");
                return e;
            } else if (msg.indexOf("MOTIVO_OBRIGATORIO_SITUACAO_INFORMADA") >= 0) {
                e = new AdsException("ZTEST.HIDROMETRO_ENSAIO.MOTIVO_OBRIGATORIO_SITUACAO_INFORMADA", 
                        Severity.ERROR,
                        "Regra inválida! Motivo é obrigatório quando a situação informada for preenchida! (MOTIVO_OBRIGATORIO_SITUACAO_INFORMADA)");
                return e;
            } else if (msg.indexOf("UK_HROEN_POSICAO_HIDROMETRO") >= 0) {
                e = new AdsException("ZTEST.HIDROMETRO_ENSAIO.UK_HROEN_POSICAO_HIDROMETRO", 
                        Severity.ERROR,
                        "Registro duplicado! Posição do hidrômetro no ensaio deve ser único Ensaio da bancada ${ENSAIO_BANCADA_ID}, Posição do modelo ${POSICAO_MODELO} (UK_HROEN_POSICAO_HIDROMETRO)");
                return e;
            } else if (msg.indexOf("FK_HROEN_MOTIVO_APROVAO_REPROVA") >= 0) {
                e = new AdsException("ZTEST.HIDROMETRO_ENSAIO.FK_HROEN_MOTIVO_APROVAO_REPROVA", 
                        Severity.ERROR,
                        "Registro não cadastrado para MOTIVO_APROVAO_REPROVA! (FK_HROEN_MOTIVO_APROVAO_REPROVA)");
                return e;
            } else if (msg.indexOf("FK_HROEN_ENSAIO_BANCADA") >= 0) {
                e = new AdsException("ZTEST.HIDROMETRO_ENSAIO.FK_HROEN_ENSAIO_BANCADA", 
                        Severity.ERROR,
                        "Registro não cadastrado para ENSAIO_BANCADA! (FK_HROEN_ENSAIO_BANCADA)");
                return e;
            } else if (msg.indexOf("PK_HROEN") >= 0) {
                e = new AdsException("ZTEST.HIDROMETRO_ENSAIO.PK_HROEN", 
                        Severity.ERROR,
                        "ID duplicado! (PK_HROEN)");
                return e;
            } else {
                e = new AdsException("ZTEST.HIDROMETRO_ENSAIO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aEnsaioBancadaId);
            allAttributes.add(aPosicaoModelo);
            allAttributes.add(aDestino);
            allAttributes.add(aSituacao);
            allAttributes.add(aSituacaoInformada);
            allAttributes.add(aMotivoAprovaoReprovaId);
            allAttributes.add(aParecer);
            allAttributes.add(aNumeroSerie);
            allAttributes.add(aHidrometroId);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getEnsaioBancadaId().toString() +
                " " + getPosicaoModelo().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByEnsaioBancadaIdPosicaoModelo(long ensaioBancadaId, int posicaoModelo) throws AdsException {
        findBy(new String[] {"ENSAIO_BANCADA_ID", "POSICAO_MODELO"},
                new Object[] {ensaioBancadaId, posicaoModelo});
    }
    
    private EntHidrometro eHidrometro;
    
    public EntHidrometro findHidrometro() throws AdsException {
        if (getHidrometroId().isNull()) {
            return null;
        }
        if (eHidrometro == null || !valueOfHidrometroId().equals(eHidrometro.valueOfId())) {
            eHidrometro = new EntHidrometro(ctx);
            eHidrometro.find(valueOfHidrometroId());
        }
        return eHidrometro;
    }
    
    /**
     * Ativa o join desta entidade com HIDROMETRO
     * através do atributo HIDROMETRO_ID
     */
    public EntHidrometro joinHidrometro() {
        return joinHidrometro(null);
    }
    public EntHidrometro joinHidrometro(String alias) {
        EntHidrometro entity = new EntHidrometro(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getHidrometroId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByHidrometro(long id, String sqlAppend) throws AdsException {
        find("select ID from HIDROMETRO_ENSAIO where HIDROMETRO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByHidrometro(long id) throws AdsException {
        findByHidrometro(id,"");
    }
    
    public void findByHidrometro(Entity entidade) throws AdsException {
        findByHidrometro(entidade.valueOfId(),"");
    }
    
    public void findByHidrometro(Entity entidade, String sqlAppend) throws AdsException {
        findByHidrometro(entidade.valueOfId(),sqlAppend);
    }
    
    private EntMotivoAprovaReprovaEnsaio eMotivoAprovaoReprova;
    
    public EntMotivoAprovaReprovaEnsaio findMotivoAprovaoReprova() throws AdsException {
        if (getMotivoAprovaoReprovaId().isNull()) {
            return null;
        }
        if (eMotivoAprovaoReprova == null || !valueOfMotivoAprovaoReprovaId().equals(eMotivoAprovaoReprova.valueOfId())) {
            eMotivoAprovaoReprova = new EntMotivoAprovaReprovaEnsaio(ctx);
            eMotivoAprovaoReprova.find(valueOfMotivoAprovaoReprovaId());
        }
        return eMotivoAprovaoReprova;
    }
    
    /**
     * Ativa o join desta entidade com MOTIVO_APROVA_REPROVA_ENSAIO
     * através do atributo MOTIVO_APROVAO_REPROVA_ID
     */
    public EntMotivoAprovaReprovaEnsaio joinMotivoAprovaoReprova() {
        return joinMotivoAprovaoReprova(null);
    }
    public EntMotivoAprovaReprovaEnsaio joinMotivoAprovaoReprova(String alias) {
        EntMotivoAprovaReprovaEnsaio entity = new EntMotivoAprovaReprovaEnsaio(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getMotivoAprovaoReprovaId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByMotivoAprovaoReprova(long id, String sqlAppend) throws AdsException {
        find("select ID from HIDROMETRO_ENSAIO where MOTIVO_APROVAO_REPROVA_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByMotivoAprovaoReprova(long id) throws AdsException {
        findByMotivoAprovaoReprova(id,"");
    }
    
    public void findByMotivoAprovaoReprova(Entity entidade) throws AdsException {
        findByMotivoAprovaoReprova(entidade.valueOfId(),"");
    }
    
    public void findByMotivoAprovaoReprova(Entity entidade, String sqlAppend) throws AdsException {
        findByMotivoAprovaoReprova(entidade.valueOfId(),sqlAppend);
    }
    
    private EntEnsaioBancada eEnsaioBancada;
    
    public EntEnsaioBancada findEnsaioBancada() throws AdsException {
        if (getEnsaioBancadaId().isNull()) {
            return null;
        }
        if (eEnsaioBancada == null || !valueOfEnsaioBancadaId().equals(eEnsaioBancada.valueOfId())) {
            eEnsaioBancada = new EntEnsaioBancada(ctx);
            eEnsaioBancada.find(valueOfEnsaioBancadaId());
        }
        return eEnsaioBancada;
    }
    
    /**
     * Ativa o join desta entidade com ENSAIO_BANCADA
     * através do atributo ENSAIO_BANCADA_ID
     */
    public EntEnsaioBancada joinEnsaioBancada() {
        return joinEnsaioBancada(null);
    }
    public EntEnsaioBancada joinEnsaioBancada(String alias) {
        EntEnsaioBancada entity = new EntEnsaioBancada(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getEnsaioBancadaId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByEnsaioBancada(long id, String sqlAppend) throws AdsException {
        find("select ID from HIDROMETRO_ENSAIO where ENSAIO_BANCADA_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByEnsaioBancada(long id) throws AdsException {
        findByEnsaioBancada(id,"");
    }
    
    public void findByEnsaioBancada(Entity entidade) throws AdsException {
        findByEnsaioBancada(entidade.valueOfId(),"");
    }
    
    public void findByEnsaioBancada(Entity entidade, String sqlAppend) throws AdsException {
        findByEnsaioBancada(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eHidrometro = null;
        eMotivoAprovaoReprova = null;
        eEnsaioBancada = null;
    }
    /**
     * Retorna os registros de VALOR_VARIAVEL_ENSAIO que referenciam este registro através do atributo HIDROMETRO_ENSAIO_ID
     */
    public EntValorVariavelEnsaio findAllValorVariavelEnsaioHidrometroEnsaio() throws AdsException {
        return findAllValorVariavelEnsaioHidrometroEnsaio("order by ID");
    }
    
    /**
     * Retorna os registros de VALOR_VARIAVEL_ENSAIO que referenciam este registro através do atributo HIDROMETRO_ENSAIO_ID
     */
    public EntValorVariavelEnsaio findAllValorVariavelEnsaioHidrometroEnsaio(String sqlAppend) throws AdsException {
        EntValorVariavelEnsaio out = new EntValorVariavelEnsaio(ctx);
        out.find("select ID from VALOR_VARIAVEL_ENSAIO where HIDROMETRO_ENSAIO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oHidrometroId.setValue(aHidrometroId);
        oNumeroSerie.setValue(aNumeroSerie);
        oParecer.setValue(aParecer);
        oMotivoAprovaoReprovaId.setValue(aMotivoAprovaoReprovaId);
        oSituacaoInformada.setValue(aSituacaoInformada);
        oSituacao.setValue(aSituacao);
        oDestino.setValue(aDestino);
        oPosicaoModelo.setValue(aPosicaoModelo);
        oEnsaioBancadaId.setValue(aEnsaioBancadaId);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntHidrometroEnsaio.class);
            rule.setName("PK_HROEN");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntHidrometroEnsaio.class);
            rule.setAssociatedEntity(EntEnsaioBancada.class);
            rule.setName("FK_HROEN_ENSAIO_BANCADA");
            rule.addAttribute(new DomId("ENSAIO_BANCADA_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntHidrometroEnsaio.class);
            rule.setAssociatedEntity(EntHidrometro.class);
            rule.setName("FK_HROEN_HIDROMETRO");
            rule.addAttribute(new DomId("HIDROMETRO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntHidrometroEnsaio.class);
            rule.setAssociatedEntity(EntMotivoAprovaReprovaEnsaio.class);
            rule.setName("FK_HROEN_MOTIVO_APROVAO_REPROVA");
            rule.addAttribute(new DomId("MOTIVO_APROVAO_REPROVA_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntHidrometroEnsaio.class);
            rule.setName("UK_HROEN_POSICAO_HIDROMETRO");
            rule.addAttribute(new DomId("ENSAIO_BANCADA_ID",""));
            rule.addAttribute(new DomInteger("POSICAO_MODELO",""));
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntHidrometroEnsaio.class);
            rule.setCheckAttribute(new DomOption("DESTINO",""));
            rule.setName("CKAV_20917871");
            rule.addAllowableValues(new String[] {"C", "E", "M", "A"});
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntHidrometroEnsaio.class);
            rule.setCheckAttribute(new DomOpcao("SITUACAO",""));
            rule.setName("CKAV_22037128");
            rule.addAllowableValues(new String[] {"E", "A", "R"});
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntHidrometroEnsaio.class);
            rule.setCheckAttribute(new DomOpcao("SITUACAO_INFORMADA",""));
            rule.setName("CKAV_22037197");
            rule.addAllowableValues(new String[] {"A", "R"});
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    protected void preInsert() throws AdsException {
        calcularDestino(); //Calcular destino
        checkRule(isParecerDeveSerPreenchidoValid(), "PARECER_DEVE_SER_PREENCHIDO", "Texto do motivo (parecer descritivo) deve ser preenchido para o motivo informado! ");
        checkRule(isMotivoObrigatorioSituacaoInformadaValid(), "MOTIVO_OBRIGATORIO_SITUACAO_INFORMADA", "Motivo é obrigatório quando a situação informada for preenchida!");
    }
    
    @Override
    protected void preUpdate() throws AdsException {
        calcularDestino(); //Calcular destino
        checkRule(isParecerDeveSerPreenchidoValid(), "PARECER_DEVE_SER_PREENCHIDO", "Texto do motivo (parecer descritivo) deve ser preenchido para o motivo informado! ");
        checkRule(isMotivoObrigatorioSituacaoInformadaValid(), "MOTIVO_OBRIGATORIO_SITUACAO_INFORMADA", "Motivo é obrigatório quando a situação informada for preenchida!");
    }
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getSituacao().isNull()) {
            setSituacao(getSituacao().getDefaultValue());
        }
        if (getDestino().isNull()) {
            setDestino(getDestino().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * Regra de validação: Motivo é obrigatório quando a situação informada for preenchida!
     */
    private Object isMotivoObrigatorioSituacaoInformadaValid() throws AdsException {
        // <user-code id="22037852" parentId="22037843" hashcode="-203a54a4" length="137">
        if (getSituacaoInformada().isNotNull()) {
            if (getMotivoAprovaoReprovaId().isNull()) {
                return false;
            }
        }
        return true;
        // </user-code>
    }
    
    /**
     * Regra de validação: Texto do motivo (parecer descritivo) deve ser preenchido para o motivo informado! 
     */
    private Object isParecerDeveSerPreenchidoValid() throws AdsException {
        // <user-code id="22041485" parentId="22040957" hashcode="2a1775b7" length="259">
        if (isMotivoAprovaoReprovaIdModified()) {
            if (getMotivoAprovaoReprovaId().isNotNull()) {
                if (findMotivoAprovaoReprova().valueOfExigeParecer().equals("S") && getParecer().isNull()) {
                    return false;
                }
            }
        }
        return true;
        
        // </user-code>
    }
    
    /**
     * Regra de ação: Calcular destino
     * 
     * Calcular o destino do hidrômetro com base na situação (ou situação 
     * informada).
     * 
     * P.ex:
     * * se situação = Reprovada, o destino é "montagem"
     * * se o ensaio é livre (sem solicitação), o destino sempre é estoque
     * * se situação = Aprovada, deve ser cliente ou estoque (esta regra deve 
     * ser apena para validar, pois o destino foi definido no aplicativo)
     */
    private void calcularDestino() throws AdsException {
        
    }
}
